package com.yinhe.controller.jibeiSync;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yinhe.model.jibeiPO.*;
import com.yinhe.service.jibeiSync.IJiBeiService;
import com.yinhe.util.RedisUtils;
import com.yinhe.util.jibeiSync.DateTimeUtil;
import com.yinhe.util.jibeiSync.redisListJsonUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// /** 1、由于HVBI接口同步一次只能是一个接口，为了确保每个表数据同步正常，会给每个同步接口，添加一个时间值作为标识，
//  * 这个值是上一次更新完成的值（采用yyyy_MM_dd'T'HH_mm_ss格式，为了匹配后面文件名称）。
//  * 2、添加一个文件同步的时间值，作为每个时刻只读取一次文件的标识。
//  * 整体思路：每个restful同步时，会优先判断：当前接口标识和读取文件的标识是否一样，如果一样便会调用文件读取。
//  * 不等会直接从redis中取得值，然后再将标识为修改。（但是这里会不会有多线程安全问题？）
//  */
// @RestController
@Slf4j
@RequestMapping("/anfen")
@Api(tags = "冀北-安分-文件解析数据（从redis中直接获取）")
public class JiBeiController {

    @Autowired
    private IJiBeiService iJiBeiService;

    @Autowired
    private RedisUtils redisUtils;

    /**
     * 获取多路短路比
     * @return
     * @throws Exception
     */
    @ApiOperation("获取多路短路比（redis中直接获取）")
    @RequestMapping(value = "/getXNY", produces = "application/json; charset=utf-8", method = RequestMethod.GET)
    public List<DSA_XNY_DLB_UN_PO> getXNY() throws Exception {
        List<DSA_XNY_DLB_UN_PO> pos = null;
        try {
            log.info("获取-多路短路比开始（redis中直接获取）");
            List<String> sccout = redisUtils.getList("DSA_XNY_DLB_UN");
            pos = redisListJsonUtil.jsonToObject(sccout, DSA_XNY_DLB_UN_PO.class);
            // pos = iJiBeiService.selectXNY("XNY.res", "DSA_XNY_DLB_UN");
        } catch (Exception e) {
            log.error("获取多路短路比失败（redis中直接获取）：原因如下：" + e.getMessage());
        }
        return pos;
    }


    /**
     * 稳定裕度分析
     * @return
     * @throws Exception
     */
    @ApiOperation("稳定裕度分析（redis中直接获取）")
    @RequestMapping(value = "/getPhase", produces = "application/json; charset=utf-8", method = RequestMethod.GET)
    public List<TTCOutput_PO> getPhase() throws Exception {
        List<TTCOutput_PO> pos = null;
        try {
            log.info("获取-稳定裕度分析（redis中直接获取）");
            List<String> sccout = redisUtils.getList("TTCOutput");
            pos = redisListJsonUtil.jsonToObject(sccout, TTCOutput_PO.class);
            // pos = iJiBeiService.selectPhase("phase2.res", "TTCOutput");
        } catch (Exception e) {
            log.error("稳定裕度分析失败（redis中直接获取）：原因如下：" + e.getMessage());
        }
        return pos;
    }


    /**
     * 静态安全分析-- 最大越限百分比
     * @return
     * @throws Exception
     */
    @ApiOperation("静态安全分析-- 最大越限百分比（redis中直接获取）")
    @RequestMapping(value = "/getPSQSOutLimitRate", produces = "application/json; charset=utf-8", method = RequestMethod.GET)
    public List<SAOUT_OVER_PO> getPSQSOutLimitRate() throws Exception {
        List<SAOUT_OVER_PO> pos = null;
        try {
            log.info("获取-静态安全分析-- 最大越限百分比（redis中直接获取）");
            List<String> sccout = redisUtils.getList("SAOUT_OVER");
            pos = redisListJsonUtil.jsonToObject(sccout, SAOUT_OVER_PO.class);
            // pos = iJiBeiService.selectPSQSOutLimitRate("PSASP_STCRIT.QS", "SAOUT_OVER");
        } catch (Exception e) {
            log.error("最大越限百分比失败（redis中直接获取）：原因如下：" + e.getMessage());
        }
        return pos;
    }

    /**
     * 暂态稳定分析--最大公交差、最低电压(两表合一，新增一个标识位（selfType），用来区分那条是最大功角差power，那条是最低电压voltage)
     * @return
     * @throws Exception
     */
    @ApiOperation("暂态稳定分析--最大公交差、最低电压(两表合一，新增一个标识位（selfType），用来区分那条是最大功角差power，那条是最低电压voltage)--（redis中直接获取）")
    @RequestMapping(value = "/getPSQSPowerAngleMax", produces = "application/json; charset=utf-8", method = RequestMethod.GET)
    public List<GD_STOUT_PO> getPSQSPowerAngleMax() throws Exception {
        List<GD_STOUT_PO> pos = null;
        try {
            log.info("获取-暂态稳定分析--最大公交差、最低电压（redis中直接获取）");
            List<String> sccout = redisUtils.getList("GD_STOUT");
            pos = redisListJsonUtil.jsonToObject(sccout, GD_STOUT_PO.class);
            // pos = iJiBeiService.selectPSQSPowerAngleMax("PSASP_STCRIT.QS", "GD_STOUT");
        } catch (Exception e) {
            log.error("暂态稳定分析--最大公交差、最低电压失败（redis中直接获取）：原因如下：" + e.getMessage());
        }
        return pos;
    }

    /**
     * 电压稳定分析
     * @return
     * @throws Exception
     */
    @ApiOperation("电压稳定分析（redis中直接获取）")
    @RequestMapping(value = "/getPSQSVoltageStabilityAnaly", produces = "application/json; charset=utf-8", method = RequestMethod.GET)
    public List<GD_VSOUT_PO> getPSQSVoltageStabilityAnaly() throws Exception {
        List<GD_VSOUT_PO> pos = null;
        try {
            log.info("获取-电压稳定分析（redis中直接获取）");
            List<String> sccout = redisUtils.getList("GD_VSOUT");
            pos = redisListJsonUtil.jsonToObject(sccout, GD_VSOUT_PO.class);
            // pos = iJiBeiService.selectPSQSVoltageStabilityAnaly("PSASP_STCRIT.QS", "GD_VSOUT");
        } catch (Exception e) {
            log.error("电压稳定分析失败（redis中直接获取）：原因如下：" + e.getMessage());
        }
        return pos;
    }


    /**
     * 最低阻尼比
     * @return
     * @throws Exception
     */
    @ApiOperation("最低阻尼比（redis中直接获取）")
    @RequestMapping(value = "/getPSQSDampingMin", produces = "application/json; charset=utf-8", method = RequestMethod.GET)
    public List<SSTOUT_PO> getPSQSDampingMin() throws Exception {
        List<SSTOUT_PO> pos = null;
        try {
            log.info("获取-最低阻尼比（redis中直接获取）");
            List<String> sccout = redisUtils.getList("SSTOUT");
            pos = redisListJsonUtil.jsonToObject(sccout, SSTOUT_PO.class);
            // pos = iJiBeiService.selectPSQSDampingMin("PSASP_STCRIT.QS", "SSTOUT");
        } catch (Exception e) {
            log.error("最低阻尼比失败（redis中直接获取）：原因如下：" + e.getMessage());
        }
        return pos;
    }


    /**
     * 最大短路电流
     * @return
     * @throws Exception
     */
    @ApiOperation("最大短路电流（redis中直接获取）")
    @RequestMapping(value = "/getPSQSShortCircuitMax", produces = "application/json; charset=utf-8", method = RequestMethod.GET)
    public List<SCCOUT_PO> getPSQSShortCircuitMax() throws Exception {
        List<SCCOUT_PO> pos = null;
        try {
            log.info("获取-最大短路电流（redis中直接获取）");
            List<String> sccout = redisUtils.getList("SCCOUT");
             pos = redisListJsonUtil.jsonToObject(sccout, SCCOUT_PO.class);
            // pos = iJiBeiService.selectPSQSShortCircuitMax("PSASP_STCRIT.QS", "SCCOUT",null);
        } catch (Exception e) {
            log.error("最大短路电流失败（redis中直接获取）：原因如下：" + e.getMessage());
        }
        return pos;
    }


    /**
     * 读取redis
     * @param key
     * @return
     */
    @ApiOperation("读取redis")
    @RequestMapping(value = "/getRedisByKey/{key}",produces = "application/json; charset=utf-8", method = RequestMethod.GET)
    public String getRedisByKey(@PathVariable("key") String key){
        String s = (String) redisUtils.get(key);
        JSONObject json = new JSONObject();
        json.put("code", "200");
        json.put("msg", "查询成功");
        json.put("data", s);
        return json.toJSONString();
    }



    @ApiOperation("三相单相最大短路电流ceshi---test---单个（redis中直接获取）")
    @RequestMapping(value = "/getXNYs2", produces = "application/json; charset=utf-8", method = RequestMethod.GET)
    public List<SCCOUT_PO> getXNYs2() throws JsonProcessingException {


        // Map<String,List<SCCOUT_PO>>
        // 遍历读取所有刻度文件
        String itemPoint ="2023_12_07T15_15_00";
         List<SCCOUT_PO> sccout_pos = iJiBeiService.selectPSQSShortCircuitMax("PSASP_STCRIT.QS", "SCCOUT", itemPoint);
            // List<String> jsonList = new ArrayList<>();
            // for (SCCOUT_PO sccout_po : sccout_pos) {
            //     ObjectMapper objectMapper = new ObjectMapper();
            //     // 将自定义对象序列化为JSON字符串
            //     String jsonString = objectMapper.writeValueAsString(sccout_po);
            //     jsonList.add(jsonString);
            // }
        List<String> jsonList = redisListJsonUtil.objectTOJson(sccout_pos);
        redisUtils.setList("SCCOUT",jsonList );

        List<String> sccout = redisUtils.getList("SCCOUT");
        // ObjectMapper objectMapper = new ObjectMapper();
        // List<SCCOUT_PO> list = new ArrayList<>();
        // for (String jsonString: sccout) {
        //     SCCOUT_PO sccout_po = objectMapper.readValue(jsonString, SCCOUT_PO.class);// 反序列化为自定义对象
        //     list.add(sccout_po);
        // }
        List<SCCOUT_PO> sccout_pos1 = redisListJsonUtil.jsonToObject(sccout, SCCOUT_PO.class);
        return sccout_pos1;
    }


}